package Window;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Random;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.imageio.ImageIO;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * Clase JTablero
 * 
 * @author Claudia Luque | Vanesa Gonzalez | Juan Jesus Fernandez | Adrian
 *         Bellido | Jose Antonio Marin
 */
public class JTablero extends JPanel {

	// ///////////////////////////////////////////////////////////////
	// CONSTANTE DE SERIALIZACION
	// ///////////////////////////////////////////////////////////////

	/** Generada por Eclipse */
	private static final long serialVersionUID = 263971044933206287L;

	// ///////////////////////////////////////////////////////////////
	// VARIABLES PRIVADAS
	// ///////////////////////////////////////////////////////////////

	/** Ancho del diagrama */
	private int width_;

	/** Altura del diagrama */
	private int height_;

	/** Imagen del tablero */
	BufferedImage tableroImage_;

	/** Imagen dama blanca casilla blanca */
	BufferedImage damaBlancaCB_;

	/** Imagen dama blanca casilla negra */
	BufferedImage damaBlancaCN_;

	/** Imagen dama blanca doble casilla blanca */
	BufferedImage dama2BlancaCB_;

	/** Imagen dama blanca doble casilla negra */
	BufferedImage dama2BlancaCN_;

	/** Imagen dama negra casilla blanca */
	BufferedImage damaNegraCB_;

	/** Imagen dama blanca casilla negra */
	BufferedImage damaNegraCN_;

	/** Imagen dama negra doble casilla blanca */
	BufferedImage dama2NegraCB_;

	/** Imagen dama blanca doble casilla negra */
	BufferedImage dama2NegraCN_;

	/** Lado casilla */
	int ladoCasilla_;

	/** Coordenadas de la esquina superior izquierda tablero */
	int xT_, yT_;

	/**
	 * Color inicial donde colocar las piezas del tablero Blanco por defecto w
	 * -> blanco b -> negro
	 */

	private String colorInicial = "W";

	/** Matriz tipo string con las piezas en el tablero */
	private String[][] piezasTablero_;

	// ///////////////////////////////////////////////////////////////
	// CONSTRUCTORES
	// ///////////////////////////////////////////////////////////////

	/**
	 * Constructor vacio
	 */
	JTablero() {
		super();

		// Damos unos valores a la altura y anchura lo suficientemente
		// grandes
		width_ = 302;
		height_ = 302;

		// Damos valores a las variables auxiliares
		ladoCasilla_ = 32;
		xT_ = yT_ = 23;

		// Leemos las distintas imagenes necesarias
		URL auxURL = null;
		try {
			auxURL = (new File("src/imagenes/tableroDamas.png")).toURI()
					.toURL();
			tableroImage_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/damaBlancaCB.png")).toURI()
					.toURL();
			damaBlancaCB_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/damaBlancaCN.png")).toURI()
					.toURL();
			damaBlancaCN_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/damaNegraCB.png")).toURI().toURL();
			damaNegraCB_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/damaNegraCN.png")).toURI().toURL();
			damaNegraCN_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/dama2BlancaCB.png")).toURI()
					.toURL();
			dama2BlancaCB_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/dama2BlancaCN.png")).toURI()
					.toURL();
			dama2BlancaCN_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/dama2NegraCB.png")).toURI()
					.toURL();
			dama2NegraCB_ = ImageIO.read(auxURL);
			auxURL = (new File("src/imagenes/dama2NegraCN.png")).toURI()
					.toURL();
			dama2NegraCN_ = ImageIO.read(auxURL);
		} catch (MalformedURLException e) {
			// Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// Auto-generated catch block
			e.printStackTrace();
		}

		iniciarPiezasTablero();
	}

	// ///////////////////////////////////////////////////////////////
	//
	// FUNCIONES PUBLICAS
	//
	// ///////////////////////////////////////////////////////////////

	/**
	 * Devuelve la matriz de piezas del tablero.
	 */
	public String[][] getPiezasTablero_() {
		return piezasTablero_;
	}

	/**
	 * Permite definir la posicion de piezas del tablero.
	 * 
	 * @param piezasTablero
	 */
	public void setPiezasTablero_(String[][] piezasTablero) {
		piezasTablero_ = piezasTablero;
	}

	/**
	 * Pinta el contenido del grafico llamando a paintComponent.
	 * 
	 * @param g
	 *            Contenido del diagrama
	 */
	public void paint(Graphics g) {
		Graphics2D g2 = (Graphics2D) g;

		// Pintamos el fondo de blanco
		g2.setColor(Color.WHITE);
		g2.fillRect(0, 0, getWidth(), getHeight());

		// Pintamos el tablero
		g2.drawImage(tableroImage_, 0, 0, tableroImage_.getWidth(null),
				tableroImage_.getHeight(null), 0, 0,
				tableroImage_.getWidth(null), tableroImage_.getHeight(null),
				null);

		// Pintamos las piezas
		String pieza;
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				// System.out.println("Falla en el: " + i + " y el: " + j);
				pieza = piezasTablero_[i][j];
				if (!pieza.equals(""))
					ponerPieza(g2, j, i, pieza);
			}
		}
	}

	/**
	 * Devuelve la anchura total del panel
	 * 
	 * @return La altura total del diagrama como int
	 */
	public int getWidth() {
		return width_;
	}

	/**
	 * Devuelve la altura total del panel
	 * 
	 * @return La altura total del diagrama como int
	 */
	public int getHeight() {
		return height_;
	}

	/**
	 * Define la anchura del panel
	 * 
	 * @param width
	 *            Anchura del panel
	 */
	public void setWidth(int width) {
		width_ = width;
	}

	/**
	 * Establece el color inicial donde se colocaran las piezas.
	 * 
	 * @param color
	 *            Color inicial.
	 */
	public void initiateBoard(String color) {
		this.colorInicial = color;
		this.iniciarPiezasTablero();
	}

	/**
	 * Crea una disposicion inicial del tablero
	 * 
	 * @param nBlancas
	 *            Cantidad inicial de damas blancas sobre el tablero.
	 * @param nNegras
	 *            Cantidad inicial de damas negras sobre el tablero.
	 * @param valor
	 *            Indica si se desea una disposicion original o aleatoria.
	 * @return piezasTablero: Matriz con la disposicion de las piezas sobre el
	 *         tablero.
	 */
	public String randomBoard(int nBlancas, int nNegras, String valor) {
		if (valor.equals("O") && this.colorInicial.equals("W")) {

			// Crear la matriz piezasTablero con una disposicion inicial
			// aleatoria teniendo en cuenta colorInicial.
			String[][] piezasTablero = {
					{ "n", "", "n", "", "n", "", "n", "" },
					{ "", "n", "", "n", "", "n", "", "n" },
					{ "n", "", "n", "", "n", "", "n", "" },
					{ "", "", "", "", "", "", "", "" },
					{ "", "", "", "", "", "", "", "" },
					{ "", "b", "", "b", "", "b", "", "b" },
					{ "b", "", "b", "", "b", "", "b", "" },
					{ "", "b", "", "b", "", "b", "", "b" }, };

			this.piezasTablero_ = piezasTablero;
			return "Disposicion original del tablero sobre casillas blancas."+"\n";
		} else if (valor.equals("O") && this.colorInicial.equals("B")) {

			String[][] piezasTablero = {
					{ "", "n", "", "n", "", "n", "", "n" },
					{ "n", "", "n", "", "n", "", "n", "" },
					{ "", "n", "", "n", "", "n", "", "n" },
					{ "", "", "", "", "", "", "", "" },
					{ "", "", "", "", "", "", "", "" },
					{ "b", "", "b", "", "b", "", "b", "" },
					{ "", "b", "", "b", "", "b", "", "b" },
					{ "b", "", "b", "", "b", "", "b", "" }, };

			this.piezasTablero_ = piezasTablero;
			return "Disposicion original del tablero sobre casillas negras."+"\n";
		}
		if (valor.equals("A")) {

			// Coloca en la matriz piezasTablero damas blancas simples y dobles,
			// damas negras simples y dobles
			// aleatoriamente sobre el tablero, teniendo en cuenta colorInicial.
			int fila, columna;
			String letra;
			this.iniciarPiezasTablero();
			int blancasDobles = nBlancas;
			nBlancas = nBlancas - (int) (Math.random() * nBlancas);
			int negrasDobles = nNegras;
			nNegras = nNegras - (int) (Math.random() * nNegras);
			blancasDobles -= nBlancas;
			negrasDobles -= nNegras;
			// Genera nBlancas
			while (nBlancas > 0) {
				columna = (int) (Math.random() * 7);
				letra = numeroToLetra(columna);
				fila = (int) (Math.random() * 7);
				if (!this.check_exist(letra, fila)
						&& this.colorCasilla(fila, columna).equals(
								this.colorInicial)) {
					this.piezasTablero_[fila][columna] = "b";
					nBlancas--;
				}
			}
			// Genera blancasDobles
			while (blancasDobles > 0) {
				columna = (int) (Math.random() * 7);
				letra = numeroToLetra(columna);
				fila = (int) (Math.random() * 7);
				if (!this.check_exist(letra, fila)
						&& this.colorCasilla(fila, columna).equals(
								this.colorInicial)) {
					this.piezasTablero_[fila][columna] = "B";
					blancasDobles--;
				}
			}
			// Genera nNegras
			while (nNegras > 0) {
				columna = (int) (Math.random() * 7);
				letra = numeroToLetra(columna);
				fila = (int) (Math.random() * 7);
				if (!this.check_exist(letra, fila)
						&& this.colorCasilla(fila, columna).equals(
								this.colorInicial)) {
					this.piezasTablero_[fila][columna] = "n";
					nNegras--;
				}
			}
			// Genera negrasDobles
			while (negrasDobles > 0) {
				columna = (int) (Math.random() * 7);
				letra = numeroToLetra(columna);
				fila = (int) (Math.random() * 7);
				if (!this.check_exist(letra, fila)
						&& this.colorCasilla(fila, columna).equals(
								this.colorInicial)) {
					this.piezasTablero_[fila][columna] = "N";
					negrasDobles--;
				}
			}
			return "Disposicion aleatoria del tablero."+"\n";
		}
		return "Error en funcion randomboard."+"\n";
	}

	/**
	 * Anade si es posible una nueva pieza al tablero.
	 * 
	 * @param color
	 *            Color de la pieza a anadir.
	 * @param letra
	 *            Letra de la columna.
	 * @param numero
	 *            Numero de la fila.
	 */
	public String addPiece(String color, String letra, int numero) {
		int numero2 = letraToNumero(letra);
		String mensajes="";
		numero = 8 - numero;
		if (numero2 != -1 && numero >= 0 && (numero) <= 7) {
			if (!this.check_exist(letra, numero)) {
				// Comprobamos si es el final del tablero, y se pasa a dama doble
				if( color.equals("b") ) {
					if( numero == 0 )
						color = "B";
				}
				else {
					if( numero == 7 )
						color = "N";
					}
					this.piezasTablero_[numero][numero2] = color;
					} else
						mensajes+="Error: La posicion destino ya esta ocupada.\n";
						//System.out.println("Error: La posicion destino ya esta ocupada.");
			} else {
				mensajes+="Error: La posicion no esta dentro de los margenes del tablero.\n";
				//System.out.println("Error: La posicion no esta dentro de los margenes del tablero.");
		}
		
		// Comprueba si el jugador ha ganado
		if( this.check(color.toUpperCase()) )
			JOptionPane.showMessageDialog(this, "El jugador " + color + " ha ganado!",
					"Enhorabuena!", JOptionPane.INFORMATION_MESSAGE);
		
		return mensajes;
	}

	/**
	 * Mueve si es posible una pieza de una casilla a otra.
	 * 
	 * @param letra1
	 *            Letra de la columna de origen.
	 * @param numero1
	 *            Numero de la fila vertical de origen.
	 * @param letra2
	 *            Letra de la columna de destino.
	 * @param numero2
	 *            Numero de la fila de destino.
	 */
	public String setupPiece(String letra1, int numero1, String letra2,
			int numero2) {
		String mensajes="";
		int numero11 = letraToNumero(letra1);
		int numero22 = letraToNumero(letra2);
		numero1=8-numero1;
		numero2=8-numero2;
		
		if (numero11 != -1 && numero22 != -1 && numero1 >= 0 && (numero1) <= 7
				&& numero2 >= 0 && (numero2) <= 7) {

			if (this.check_exist(letra1, numero1)) {
				this.quitarPieza(letra1,8-numero1);
				mensajes+=this.addPiece(this.piezasTablero_[numero1][numero11], letra2,
						numero2);
			} else
				mensajes+="Error: La posicion origen no tiene ninguna pieza.\n";
				//System.out.println("Error: La posicion origen no tiene ninguna pieza.");
		} else {
			mensajes+="Error: La posicion no esta dentro de los margenes del tablero.\n";
			//System.out.println("Error: La posicion no esta dentro de los margenes del tablero.");
		}
		return mensajes;
	}

	/**
	 * Devuelve true si el jugador del color especificado en la variable
	 * expr_cad, ha ganado y false en caso contrario.
	 * 
	 * @param str
	 * @return true/false
	 */
	public boolean check(String str) {
		String color = "";

		if (str.equals("N"))
			color = "B";
		else
			color = "N";

		int Npiezas = ratio(color);

		if (Npiezas == 0)
			return true;
		else
			return false;

	}

	/**
	 * Comprueba si hay una pieza en la coordenada determinada por la expresion
	 * expr_cad, expr_ent.
	 * 
	 * @param str
	 * @param num
	 * @return true/false
	 */
	public boolean check_exist(String str, int num) {

		int cordx = letraToNumero(str);
		int cordy = num;
		String piezaux = this.piezasTablero_[cordy][cordx];

		if (piezaux.equals(""))
			return false;
		else
			return true;

	}

	/**
	 * Comprueba si hay una dama doble en la coordenada determinada por la
	 * expresion expr_cad, expr_ent. Si no hay pieza en esa coordenada devuelve
	 * false.
	 * 
	 * @param str
	 * @param num
	 * @return true/false
	 */
	public boolean check_damadoble(String str, int num) {

		if (check_exist(str, 8 - num)) {
			int cordx = letraToNumero(str);
			int cordy = 8 - num;
			String piezaux = this.piezasTablero_[cordy][cordx];

			if (piezaux.equals("B") || piezaux.equals("N"))
				return true;
			else
				return false;
		} else
			return false;

	}

	/**
	 * Comprueba si hay una pieza en la coordenada determinada por la expresion
	 * expr_cad, expr_ent y devuelve "b" si el color de la pieza es blanco y "n"
	 * si la pieza es negra. Si no hay pieza en esa coordenada devuelve "error".
	 * 
	 * @param str
	 * @param num
	 * @return "n"/"b"/"error"
	 */
	public String piece_color(String str, int num) {

		if (check_exist(str, 8 - num)) {
			int cordx = letraToNumero(str);
			int cordy = 8 - num;
			String pieza = piezasTablero_[cordy][cordx];

			if (pieza.equals("B") || pieza.equals("b"))
				return "b";
			else
				return "n";
		} else
			return "error";

	}

	/**
	 * Devuelve el numero de piezas del color especificado en el parametro
	 * color.
	 * 
	 * @param color
	 * @return Npiezas
	 */
	public int ratio(String color) {

		int Npiezas = 0;
		String col=color.toLowerCase();		

		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				if (piezasTablero_[i][j].equals(col) || piezasTablero_[i][j].equals(color))
					Npiezas++;
			}
		}
		return Npiezas;
	}

	/**
	 * Genera un tablero VRML con las piezas del tablero
	 * 
	 * @param nombreFichero
	 *            Nombre del archivo vrml con el tablero
	 * 
	 */
	public String generarTableroVRML() {
		String resultado = "El tablero VRML, situado en el archivo src/tableroVRML/damasSalida.wrl, ha sido generado correctamente.";
		try{
			String nombreEsqueleto = "src/esqueletoDamasVRML/damasEsqueleto.wrl";
			String nombreDestino = "src/tableroVRML/damasSalida.wrl";
			TableroVRML tableroVRML = new TableroVRML(nombreEsqueleto, nombreDestino);
			tableroVRML.crearTablero(piezasTablero_);
		} catch (IOException e) {
			resultado = "Error: No ha sido posible crear el fichero VRML.";
		}
		return resultado;
	}

	/**
	 * Quita una pieza del tablero segun sus coordenadas
	 * 
	 * @param letraColumna
	 *            String con la letra de la columna del tablero
	 * 
	 * @param numeroFila
	 *            Numero de fila del tablero
	 */

	public void quitarPieza(String letraColumna, int numeroFila) {

		// Calculamos el numero de la columna de la pieza
		int numeroColumna = letraToNumero(letraColumna);
		int filaMatriz = 8 - numeroFila;

		// Comprobamos que la pieza esta incluida
		if (check_exist(letraColumna, filaMatriz)) {
			// Si no existe actualizamos el valor de la matriz de piezas
			piezasTablero_[filaMatriz][numeroColumna] = "";

			// Repintamos el tablero
			this.repaint();
		}
		// Si no existe imprimimos un mensaje diciendolo
		else {
			System.out.println("Error: La casilla " + numeroFila + ":"
					+ letraColumna + " esta vacia.");
		}

		// Incrementamos el contador de ordenes
	}

	/**
	 * Mueve una pieza blanca a las coordenadas especificadas
	 * 
	 * @param columnaOrigen
	 *            String con la letra de la columna de origen del tablero
	 * 
	 * @param filaOrigen
	 *            Numero de fila de origen del tablero
	 * 
	 * @param columnaDestino
	 *            String con la letra de la columna de destino del tablero
	 * 
	 * @param filaDestino
	 *            Numero de fila de destino del tablero
	 */

	public String moverPiezaBlanca(String columnaOrigen, int filaOrigen,
		String columnaDestino, int filaDestino) {
		int fo = 8 - filaOrigen;
		int fd = 8 - filaDestino;
		String color="";
		String mensaje = "";

		// Comprobamos que la casilla de destino esta vacia
		if (this.check_exist(columnaDestino, fd)) {
			mensaje += "Error: La casilla " + filaDestino + ":"
					+ columnaDestino + " esta ocupada.\n";
		} else {
			int co = this.letraToNumero(columnaOrigen);
			int cd= this.letraToNumero(columnaDestino);

			// Comprobamos que la ficha esta en ese sitio y es blanca
			if (this.piece_color(columnaOrigen, filaOrigen).equals("b") && !check_damadoble(columnaOrigen,filaOrigen)){
				if((cd==co+1 || cd==co-1)&&(fd==fo-1)){
							
					// Solo quitamos la pieza en la poscion de origen
					this.quitarPieza(columnaOrigen, filaOrigen);

					// Y la ponemos en la de destino
					addPiece("b",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
					//Se come una pieza negra que esta a la derecha
				}else if(cd==co+2 && fd==fo-2 && piece_color(this.numeroToLetra(co+1),filaOrigen+1).equals("n")){
					// Quitamos la pieza en la poscion de origen y se quita la pieza negra
					this.quitarPieza(columnaOrigen, filaOrigen);
					this.quitarPieza(this.numeroToLetra(co+1),filaOrigen+1);
					
					mensaje += "La pieza blanca se come una pieza negra.\n";

					// Y la ponemos en la de destino
					addPiece("b",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
					
					//Se come una pieza negra que esta a la izquierda
				}else if(cd==co-2 && fd==fo-2 && piece_color(this.numeroToLetra(co-1),filaOrigen+1).equals("n")){
					// Quitamos la pieza en la poscion de origen y se quita la pieza negra
					this.quitarPieza(columnaOrigen, filaOrigen);
					this.quitarPieza(this.numeroToLetra(co-1),filaOrigen+1);
					
					mensaje += "La pieza blanca se come una pieza negra.\n";

					// Y la ponemos en la de destino
					addPiece("b",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
				}else
				 mensaje += "Movimiento no valido.\n";
				
				//La pieza es doble
			} else if(this.piece_color(columnaOrigen, filaOrigen).equals("b") && check_damadoble(columnaOrigen,filaOrigen)){
				int faux=fd-fo;
				int caux=cd-co;
				if((fd==fo+faux || fd==fo-faux) && (cd==co+faux || cd==co-faux)){
					if(caux==1 || caux==-1){
						this.quitarPieza(columnaOrigen, filaOrigen);
						addPiece("B",columnaDestino,filaDestino);
						this.repaint();
					}else if(caux>1 && faux<-1){
						for(int i=1;i<caux;i++){
							color=piece_color(numeroToLetra(co+i),filaOrigen+i);
							
							if(color.equals("b"))
								mensaje += "Movimiento no valido.\n";
							else if(color.equals("n"))
								quitarPieza(numeroToLetra(co+i),filaOrigen+i);
							
						}
					}else if(caux<-1 && faux<-1){
						for(int i=1;i<Math.abs(caux);i++){
							color=piece_color(numeroToLetra(co-i),filaOrigen+i);
							if(color.equals("b"))
								mensaje += "Movimiento no valido.\n";
							else if(color.equals("n"))
								quitarPieza(numeroToLetra(co-i),filaOrigen+i);
							
						}
		
				}else if(caux>1 && faux>1){
					for(int i=1;i<caux;i++){
						color=piece_color(numeroToLetra(co+i),filaOrigen-i);
						if(color.equals("b"))
							mensaje += "Movimiento no valido.\n";
						else if(color.equals("n"))
							quitarPieza(numeroToLetra(co+i),filaOrigen-i);
						
					}
					
				}else if(caux<-1 && faux>1){
					for(int i=1;i<faux;i++){
						color=piece_color(numeroToLetra(co-i),filaOrigen-i);
						if(color.equals("b"))
							mensaje += "Movimiento no valido.\n";
						else if(color.equals("n"))
							quitarPieza(numeroToLetra(co-i),filaOrigen-i);
					}
					
				}
						if(!color.equals("b")){
							this.quitarPieza(columnaOrigen, filaOrigen);
							addPiece("B",columnaDestino,filaDestino);
							this.repaint();
						}
				}
				
			// Sino imprimimos los errores segun corresponda
			// La pieza no existe
			}else if (!this.check_exist(columnaOrigen, fo)) {
				mensaje += "Error: La casilla " + filaOrigen + ":"
						+ columnaOrigen + " esta vacia.\n";
			}
			// La pieza existe pero es negra
			else if (piece_color(columnaOrigen, filaOrigen).equals("n")){
				mensaje += "Error: La casilla " + filaOrigen + ":"
						+ columnaOrigen + " contiene una pieza negra.\n";
			}
		}
		return mensaje;
	}

	/**
	 * Mueve una pieza negra a las coordenadas especificadas
	 * 
	 * @param columnaOrigen
	 *            String con la letra de la columna de origen
	 * 
	 * @param filaOrigen
	 *            Numero de fila de origen
	 * 
	 * @param columnaDestino
	 *            String con la letra de la columna de destino
	 * 
	 * @param filaDestino
	 *            Numero de fila de destino
	 */

	public String moverPiezaNegra(String columnaOrigen, int filaOrigen,
		String columnaDestino, int filaDestino) {
		int fo = 8 - filaOrigen;
		int fd = 8 - filaDestino;
		String color="";
		String mensaje = "";

		// Comprobamos que la casilla de destino esta vacia
		if (this.check_exist(columnaDestino, fd)) {
			mensaje += "Error: La casilla " + filaDestino + ":"
					+ columnaDestino + " esta ocupada.\n";
		} else {
			int co = this.letraToNumero(columnaOrigen);
			int cd= this.letraToNumero(columnaDestino);

			// Comprobamos que la ficha esta en ese sitio y es blanca
			if (this.piece_color(columnaOrigen, filaOrigen).equals("n") && !check_damadoble(columnaOrigen,filaOrigen)){
				if((cd==co+1 || cd==co-1)&&(fd==fo+1)){
							
					// Solo quitamos la pieza en la poscion de origen
					this.quitarPieza(columnaOrigen, filaOrigen);

					// Y la ponemos en la de destino
					addPiece("n",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
					//Se come una pieza blanca que esta a la derecha
				}else if(cd==co+2 && fd==fo+2 && piece_color(this.numeroToLetra(co+1),filaOrigen-1).equals("b")){
					// Quitamos la pieza en la poscion de origen y se quita la pieza negra
					this.quitarPieza(columnaOrigen, filaOrigen);
					this.quitarPieza(this.numeroToLetra(co+1),filaOrigen-1);
					
					mensaje += "La pieza negra se come una pieza blanca.\n";

					// Y la ponemos en la de destino
					addPiece("n",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
					
					//Se come una pieza negra que esta a la izquierda
				}else if(cd==co-2 && fd==fo+2 && piece_color(this.numeroToLetra(co-1),filaOrigen-1).equals("b")){
					// Quitamos la pieza en la poscion de origen y se quita la pieza negra
					this.quitarPieza(columnaOrigen, filaOrigen);
					this.quitarPieza(this.numeroToLetra(co-1),filaOrigen-1);
					
					mensaje += "La pieza negra se come una pieza blanca.\n";

					// Y la ponemos en la de destino
					addPiece("n",columnaDestino,filaDestino);

					// Repintamos el tablero
					this.repaint();
				}else
				 mensaje += "Movimiento no valido.\n";
				
				//La pieza es doble
			} else if(this.piece_color(columnaOrigen, filaOrigen).equals("n") && check_damadoble(columnaOrigen,filaOrigen)){
				int faux=fd-fo;
				int caux=cd-co;
				if((fd==fo+faux || fd==fo-faux) && (cd==co+faux || cd==co-faux)){
					if(caux==1 || caux==-1){
						this.quitarPieza(columnaOrigen, filaOrigen);
						addPiece("N",columnaDestino,filaDestino);
						this.repaint();
					}else if(caux>1 && faux<-1){
						for(int i=1;i<caux;i++){
							color=piece_color(numeroToLetra(co+i),filaOrigen+i);
							
							if(color.equals("n"))
								mensaje += "Movimiento no valido.\n";
							else if(color.equals("b"))
								quitarPieza(numeroToLetra(co+i),filaOrigen+i);
							
						}
					}else if(caux<-1 && faux<-1){
						for(int i=1;i<Math.abs(caux);i++){
							color=piece_color(numeroToLetra(co-i),filaOrigen+i);
							if(color.equals("n"))
								mensaje += "Movimiento no valido.\n";
							else if(color.equals("b"))
								quitarPieza(numeroToLetra(co-i),filaOrigen+i);
							
						}
		
				}else if(caux>1 && faux>1){
					for(int i=1;i<caux;i++){
						color=piece_color(numeroToLetra(co+i),filaOrigen-i);
						if(color.equals("n"))
							mensaje += "Movimiento no valido.\n";
						else if(color.equals("b"))
							quitarPieza(numeroToLetra(co+i),filaOrigen-i);
						
					}
					
				}else if(caux<-1 && faux>1){
					for(int i=1;i<faux;i++){
						color=piece_color(numeroToLetra(co-i),filaOrigen-i);
						if(color.equals("n"))
							mensaje += "Movimiento no valido.\n";
						else if(color.equals("b"))
							quitarPieza(numeroToLetra(co-i),filaOrigen-i);
					}
					
				}
						if(!color.equals("n")){
							this.quitarPieza(columnaOrigen, filaOrigen);
							addPiece("N",columnaDestino,filaDestino);
							this.repaint();
						}
				}
				
			
			// Sino imprimimos los errores segun corresponda
			// La pieza no existe
			}else if (!this.check_exist(columnaOrigen, fo)) {
				mensaje += "Error: La casilla " + filaOrigen + ":"
						+ columnaOrigen + " esta vacia.\n";
			}
			// La pieza existe pero es negra
			else if (piece_color(columnaOrigen, filaOrigen).equals("b")){
				mensaje += "Error: La casilla " + filaOrigen + ":"
						+ columnaOrigen + " contiene una pieza blanca.\n";
			}
		}
		return mensaje;
	}
	
	
	///////////////////////////////////////////
	// FUNCIONES DE JUAN JESUS
	
	
	public int singleRowToChessRow(int fila){
		int row=0;
		
		switch(fila){
			case 0:
				row=8;
				break;
				
			case 1:
				row=7;
				break;
				
			case 2:
				row=6;
				break;
				
			case 3:
				row=5;
				break;
				
			case 4:
				row=4;
				break;
				
			case 5:
				row=3;
				break;
				
			case 6:
				row=2;
				break;
				
			case 7:
				row=1;
				break;
		}
		
		return row;
	}
	
	
	/**
	 * Mueve aleatoriamente una pieza blanca
	 * 
	 */
	public String move_radomly_w(){
		
		int i =0, j = 0;
		int fila_mas_avanzada = 1;
		int columna_mas_avanzada =0;
			
		boolean imposible_mover =false;		
		
		String mensaje = "";
		
		boolean encontrada_mas_avanzada = false;
		
		Vector<Integer> posiciones = new Vector<Integer>();
		
		
		for(i = 1; i <= 5 && !encontrada_mas_avanzada; i++){			
			for(j = 0; j < this.piezasTablero_[i].length; j++){
				//mensaje+=this.piezasTablero_[i][j];
				//mensaje+= " pos: "+ i +" pos:"+j +" = " + this.piezasTablero_[i][j]+" ";
				
				if(this.piezasTablero_[i][j].equals("b") ){
					
					encontrada_mas_avanzada = true;
					posiciones.add(j);			
					fila_mas_avanzada = singleRowToChessRow(i);		
					//mensaje+="\nENCONTRADA FICHA EN FILA MAS AVANZADA: " + fila_mas_avanzada + " J: " + j;
				}
			}
		}
		
		
		//Seleccionamos la ficha a mover de las que esten mas avanzadas
		if(posiciones.size()>1){
						
			int columna_aleatoria= 0;			
			//mensaje+="\n ESTA MIERDA QUE ES: " +		posiciones.elementAt(posiciones.size()-1);	
			double columna_aleatoria2 = Math.random() * (posiciones.size()) ;
			 
			//mensaje+="\nCOLUMNA ALEATORIA 1 " + columna_aleatoria2;
			
			columna_aleatoria = (int) columna_aleatoria2;
			
			//mensaje+="\nCOLUMNA ALEATORIA 2 " + columna_aleatoria;			 

			columna_mas_avanzada = posiciones.elementAt(columna_aleatoria);//columna_aleatoria;
		}
		else{		
			columna_mas_avanzada = posiciones.firstElement();
			//mensaje += "\nSOLO EXISTE ESTA COLUMNA: " + columna_mas_avanzada;
		}
		//mensaje+="\nFILA MAS AVANZADA: " +fila_mas_avanzada + " COLUMNA MAS AVANZADA: "+columna_mas_avanzada;		
		
		
		
		//REALIZAMOS EL MOVIMIENTO SEGUN EL CASO
		if(columna_mas_avanzada == 0){
			mensaje+="Solo movimiento hacia la derecha.\n";
			
			//mensaje+="\n WOW: " +this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada+1];
			
			//mensaje+="\n EO: " + this.numeroToLetra(columna_mas_avanzada+1)+ " EO: " +(fila_mas_avanzada+1);// + " NUMERO1: " +n1 + " NUMERO2: "+n2;
			
			//mensaje+="\nLA FILA MAS AVANZADA PARA VER ES: "+(fila_mas_avanzada-1) + " Y LA COLUMNA: ";
			if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada+1]!=""){
				mensaje+="Hay una pieza ahi 1.\n";
								
				if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada+1].equals("b")){
					//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
					
					imposible_mover = true;
					
					//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
					posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					
					mensaje+="0.Movimiento aleatorio: Imposible mover.\n";
				}
				else{
					//mensaje+=" Y ES DE COLOR NEGRO";
					
					if(this.piezasTablero_[fila_mas_avanzada-2][columna_mas_avanzada+2] == ""){
						
						//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
						this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada+2), fila_mas_avanzada+2);
					
						mensaje+="1.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
						+ this.numeroToLetra(columna_mas_avanzada+2) + " "+(fila_mas_avanzada+2)+"\n";
					
					}
					else{
						mensaje+="2.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover.\n";
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}	
				}
			}
			else{
				mensaje+="No hay una pieza ahi 1.\n";
								
				//mensaje+="\nLETRA1: " + letra1+ " LETRA2: " +letra2 + " NUMERO1: " +n1 + " NUMERO2: "+n2;
				this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada+1), fila_mas_avanzada+1);		
				
				mensaje+="3.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
				+ this.numeroToLetra(columna_mas_avanzada+1) + " "+(fila_mas_avanzada+1)+"\n";
			}
			
			
		}else if(columna_mas_avanzada == 7){
			//mensaje+="\nSOLO MOVIMIENTO HACIA LA IZQUIERDA";
			
			if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada-1]!=""){
				//mensaje+="\nHAY UNA PIEZA AHI 2";				
				
				if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada-1].equals("b")){
					//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
					
					imposible_mover = true;
					
					//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
					posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
				}
				else{
					//mensaje+=" Y ES DE COLOR NEGRO";
					
					if(this.piezasTablero_[fila_mas_avanzada-2][columna_mas_avanzada-2] == ""){
						
						//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
						this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada-2), fila_mas_avanzada+2);
					
						mensaje+="4.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
						+ this.numeroToLetra(columna_mas_avanzada-2) + " "+(fila_mas_avanzada+2)+"\n";
					
					}
					else{
						mensaje+="5.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover.\n";
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}	
				}	
			}
			else{
				//mensaje+="\nNO HAY UNA PIEZA AHI 2";
				
				this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada-1), fila_mas_avanzada+1);	
				
				mensaje+="6.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
				+ this.numeroToLetra(columna_mas_avanzada-1) + " "+(fila_mas_avanzada+1)+"\n";
			}			
		}else{
			mensaje+="Hay que seleccionar el movimiento aleatorio.\n";
			
			double izq_dere = (Math.random() * 2) ;			 
			//mensaje+="\nLADO ALEATORIO: " + izq_dere;		
			int izq_dere2 = (int) izq_dere;			
			//mensaje+="\nLADO ALEATORIO 2: " + izq_dere2;
			
			//SI ES 0 MOVIMIENTO HACIA LA IZQUIERDA, SI ES 1 MOVIMIENTO HACIA LA DERECHA
			
			//MOVIMIENTO HACIA LA IZQUIERDA
			//izq_dere2=1;
			if(izq_dere2 == 0){
				mensaje+="Nos movemos hacia la izquierda.\n";
				
				if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada-1]!=""){
					//mensaje+="\nHAY UNA PIEZA AHI 3";
					
					if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada-1].equals("b")){
						//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
						
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
						
						mensaje+="6-5.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover.\n";
						
					}else{
						
						//mensaje+=" Y ES DE COLOR NEGRO";
						
						if(this.piezasTablero_[fila_mas_avanzada-2][columna_mas_avanzada-2] == ""){
							
							//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
							this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada-2), fila_mas_avanzada+2);
						
							mensaje+="7.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
							+ this.numeroToLetra(columna_mas_avanzada-2) + " "+(fila_mas_avanzada+2)+"\n";
						
						}
						else{
							mensaje+="8.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover.\n";
							
							imposible_mover = true;
							
							//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
							posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
							
							
						}	
						
					}
				}
				else{
					//mensaje+="\nNO HAY UNA PIEZA AHI 3";					
					this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada-1), fila_mas_avanzada+1);
					
					mensaje+="9.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
					+ this.numeroToLetra(columna_mas_avanzada-1) + " "+(fila_mas_avanzada+1)+"\n";
				}				
			}
			
			//MOVIMIENTO HACIA LA DERECHA
			else{
				//mensaje+="\nNOS MOVEMOS HACIA LA DERECHA";
				
				if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada+1]!=""){
					//mensaje+="\nHAY UNA PIEZA AHI 4";
					
					if(this.piezasTablero_[fila_mas_avanzada-1][columna_mas_avanzada+1].equals("b")){
						//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
						mensaje+="10.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover.\n";
						
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}
					else{
						
						//mensaje+=" Y ES DE COLOR NEGRO";
						
						if(this.piezasTablero_[fila_mas_avanzada-2][columna_mas_avanzada+2] == ""){
							
							//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
							this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada+2), fila_mas_avanzada+2);
						
							mensaje+="11.Movimiento aleatorio 1: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
							+ this.numeroToLetra(columna_mas_avanzada+2) + " "+(fila_mas_avanzada+2)+"\n";
						}
						else{
							mensaje+="12.Movimiento aleatorio: La posicion esta ocupada. Imposible mover.\n";
							imposible_mover = true;
							
							//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
							posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
						}						
					}
				}
				else{
					//mensaje+="\nNO HAY UNA PIEZA AHI 4";					
					this.moverPiezaBlanca(this.numeroToLetra(columna_mas_avanzada), fila_mas_avanzada, this.numeroToLetra(columna_mas_avanzada+1), fila_mas_avanzada+1);
					
					mensaje+="13.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ (fila_mas_avanzada)+ " a: " 
					+ this.numeroToLetra(columna_mas_avanzada+1) + " "+(fila_mas_avanzada+1)+"\n";
				}
			}
		}
		
		posiciones.clear();
		
		return mensaje;		
	}
	
	
	/**
	 *  Mueve aleatoriamente una pieza negra
	 *  
	 */
	public String move_radomly_b(){
		int i =0, j = 0;
		int fila_mas_avanzada = 1;
		int columna_mas_avanzada =0;
			
		boolean imposible_mover =false;		
		
		String mensaje = "";
		
		boolean encontrada_mas_avanzada = false;
		
		Vector<Integer> posiciones = new Vector<Integer>();
		
		
		for(i = 6; i >= 2 && !encontrada_mas_avanzada; i--){			
			for(j = 0; j < this.piezasTablero_[i].length; j++){
				//mensaje+=this.piezasTablero_[i][j];
				//mensaje+= " pos: "+ i +" pos:"+j +" = " + this.piezasTablero_[i][j]+" ";
				
				if(this.piezasTablero_[i][j].equals("n") ){
					//mensaje+="\nENCONTRADA FICHA EN FILA MAS AVANZADA: " + fila_mas_avanzada + " J: " + j;
					encontrada_mas_avanzada = true;
					posiciones.add(j);			
					fila_mas_avanzada = i;					
					//mensaje+="\nENCONTRADA FICHA EN FILA MAS AVANZADA: " + fila_mas_avanzada + " J: " + j;
				}
			}
			//mensaje+="\n";
		}
		
		
		//Seleccionamos la ficha a mover de las que esten mas avanzadas
		if(posiciones.size()>1){
						
			int columna_aleatoria= 0;			
			//mensaje+="\n ESTA MIERDA QUE ES: " +		posiciones.elementAt(posiciones.size()-1);	
			double columna_aleatoria2 = Math.random() * (posiciones.size()) ;
			 
			//mensaje+="\nCOLUMNA ALEATORIA 1 " + columna_aleatoria2;
			
			columna_aleatoria = (int) columna_aleatoria2;
			
			//mensaje+="\nCOLUMNA ALEATORIA 2 " + columna_aleatoria;			 

			columna_mas_avanzada = posiciones.elementAt(columna_aleatoria);//columna_aleatoria;
		}
		else{		
			columna_mas_avanzada = posiciones.firstElement();
			//mensaje += "\nSOLO EXISTE ESTA COLUMNA: " + columna_mas_avanzada;
		}
		mensaje+="Fila mas avanzada: " +fila_mas_avanzada + " Columna mas avanzada: "+columna_mas_avanzada+"\n";		
		
		

		
		//REALIZAMOS EL MOVIMIENTO SEGUN EL CASO
		if(columna_mas_avanzada == 0){
			//mensaje+="\nSOLO MOVIMIENTO HACIA LA DERECHA";
			
			if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada+1]!=""){
				//mensaje+="\nHAY UNA PIEZA AHI 1";
								
				if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada+1].equals("n")){
					//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
					
					imposible_mover = true;
					
					//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
					posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					
					mensaje+="0.Movimiento aleatorio negro: Imposible mover."+"\n";
				}
				else{
					//mensaje+=" Y ES DE COLOR NEGRO";
					
					if(this.piezasTablero_[fila_mas_avanzada+2][columna_mas_avanzada+2] == ""){
						
						//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
						this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada+2), this.singleRowToChessRow(fila_mas_avanzada+2));
					
						mensaje+="1.Movimiento aleatorio de negro: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
						+ this.numeroToLetra(columna_mas_avanzada+2) + " "+this.singleRowToChessRow(fila_mas_avanzada-2)+"\n";

					
					}
					else{
						mensaje+="2.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}	
				}
			}
			else{
				//mensaje+="\nNO HAY UNA PIEZA AHI 1";
								
				//mensaje+="\nLETRA1: " + letra1+ " LETRA2: " +letra2 + " NUMERO1: " +n1 + " NUMERO2: "+n2;
				this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada+1), this.singleRowToChessRow(fila_mas_avanzada+1));		


				mensaje+="3.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
				+ this.numeroToLetra(columna_mas_avanzada+1) + " "+this.singleRowToChessRow(fila_mas_avanzada+1)+"\n";

			}
			
			
			
		}else if(columna_mas_avanzada == 7){
			//mensaje+="\nSOLO MOVIMIENTO HACIA LA IZQUIERDA";
			
			if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada-1]!=""){
				mensaje+="Hay una pieza ahi 2"+"\n";				
				
				if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada-1].equals("n")){
					//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";n
					
					imposible_mover = true;
					
					//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
					posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
				}
				else{
					//mensaje+=" Y ES DE COLOR NEGRO";
					
					if(this.piezasTablero_[fila_mas_avanzada+2][columna_mas_avanzada-2] == ""){
						
						//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
						this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada-2), this.singleRowToChessRow(fila_mas_avanzada-2));
					
						mensaje+="4.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
						+ this.numeroToLetra(columna_mas_avanzada-2) + " "+this.singleRowToChessRow(fila_mas_avanzada+2)+"\n";
					
					}
					else{
						mensaje+="5.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}	
				}	
			}
			else{
				//mensaje+="\nNO HAY UNA PIEZA AHI 2";
				
				this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada-1), this.singleRowToChessRow(fila_mas_avanzada+1));	

			     mensaje+="6.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+  this.singleRowToChessRow(fila_mas_avanzada)+ " a: " 
                 + this.numeroToLetra(columna_mas_avanzada-1) + " "+this.singleRowToChessRow(fila_mas_avanzada+1)+"\n";

			}	
			
			
			
			
		}else{
			mensaje+="Hay que seleccionar el movimiento aleatorio."+"\n";
			
			double izq_dere = (Math.random() * 2) ;			 
			//mensaje+="\nLADO ALEATORIO: " + izq_dere;		
			int izq_dere2 = (int) izq_dere;			
			//mensaje+="\nLADO ALEATORIO 2: " + izq_dere2;
			
			//SI ES 0 MOVIMIENTO HACIA LA IZQUIERDA, SI ES 1 MOVIMIENTO HACIA LA DERECHA
			
			//MOVIMIENTO HACIA LA IZQUIERDA
			//izq_dere2=1;
			if(izq_dere2 == 0){
				mensaje+="Nos movemos hacia la izquierda."+"\n";
				
				if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada-1]!=""){
					//mensaje+="\nHAY UNA PIEZA AHI 3";
					
					if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada-1].equals("n")){
						//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
						
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
						
						mensaje+="6-5.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
						
					}else{
						//TODO 
						//mensaje+=" Y ES DE COLOR NEGRO";
						
						if(this.piezasTablero_[fila_mas_avanzada+2][columna_mas_avanzada-2] == ""){
							
							//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
							this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada-2), this.singleRowToChessRow(fila_mas_avanzada+2));
						

							mensaje+="7.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ fila_mas_avanzada+ " a: " 
							+ this.numeroToLetra(columna_mas_avanzada-2) + " "+this.singleRowToChessRow(fila_mas_avanzada+2)+"\n";
						
						}
						else{
							mensaje+="8.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
							
							imposible_mover = true;
							
							//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
							posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
							
							
						}	
						
					}
				}
				else{
					//mensaje+="\nNO HAY UNA PIEZA AHI 3";					
					this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada-1), this.singleRowToChessRow(fila_mas_avanzada+1));
					
					mensaje+="9.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ this.singleRowToChessRow(fila_mas_avanzada)+ " a: " 
					+ this.numeroToLetra(columna_mas_avanzada-1) + " "+(this.singleRowToChessRow(fila_mas_avanzada+1))+"\n";
				}				
			}
			
			//MOVIMIENTO HACIA LA DERECHA
			else{
				mensaje+="Nos movemos hacia la derecha."+"\n";
				
				if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada+1]!=""){
					//mensaje+="\nHAY UNA PIEZA AHI 4";
					
					if(this.piezasTablero_[fila_mas_avanzada+1][columna_mas_avanzada+1].equals("n")){
						//mensaje+=" Y ES DE COLOR BLANCO. IMPOSIBLE MOVER";
						mensaje+="10.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
						
						imposible_mover = true;
						
						//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
						posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
					}
					else{
						//TODO
						//mensaje+=" Y ES DE COLOR NEGRO";
						
						if(this.piezasTablero_[fila_mas_avanzada+2][columna_mas_avanzada+2] == ""){
							
							//SI ESTA VACIA LA SIGUIENTE POSICION NOS COMEMOS LA FICHA
							this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada+2), this.singleRowToChessRow(fila_mas_avanzada+2));
						
							mensaje+="11.Movimiento aleatorio de 1: " + this.numeroToLetra(columna_mas_avanzada) + " "+ this.singleRowToChessRow(fila_mas_avanzada)+ " a: " 
							+ this.numeroToLetra(columna_mas_avanzada+2) + " "+ this.singleRowToChessRow(fila_mas_avanzada+2)+"\n";
						}
						else{
							mensaje+="12.Movimiento aleatorio: La siguiente posicion esta ocupada. Imposible mover."+"\n";
							imposible_mover = true;
							
							//Ya que no se puede mover, lo eliminamos de la lista de posibles fichas a mover
							posiciones.remove(posiciones.indexOf(columna_mas_avanzada));
						}						
					}
				}
				else{
					//mensaje+="\nNO HAY UNA PIEZA AHI 4";					
					this.moverPiezaNegra(this.numeroToLetra(columna_mas_avanzada), this.singleRowToChessRow(fila_mas_avanzada), this.numeroToLetra(columna_mas_avanzada+1), this.singleRowToChessRow(fila_mas_avanzada+1));
					
					mensaje+="13.Movimiento aleatorio de: " + this.numeroToLetra(columna_mas_avanzada) + " "+ this.singleRowToChessRow(fila_mas_avanzada)+ " a: " 
					+ this.numeroToLetra(columna_mas_avanzada+1) + " "+ this.singleRowToChessRow(fila_mas_avanzada+1)+"\n";
				}
			}
		}
		
		posiciones.clear();
		
		
		
		return mensaje;
	}
	
	
	/**
	 * Guarda el estado de la partida de damas actual
	 * 
	 * @param ruta
	 * 				La ruta del archivo donde se almacenara el estado actual de la partida
	 */	
	public String state(String ruta){
		// TODO
		String mensaje="";
		
		File fil = new File("./estado.txt");
		
		mensaje+="La ruta es: " + ruta+"\n";
		PrintWriter writer = null;
		try {
			fil.createNewFile();
			
			writer = new PrintWriter(fil);
			
			for(int i = 0; i < this.piezasTablero_.length; i++){
				for(int j= 0; j < this.piezasTablero_[i].length; j++){
					if(this.piezasTablero_[i][j].equals("")){
						writer.print("-"+this.piezasTablero_[i][j]);
					}
					else{
						writer.print(""+this.piezasTablero_[i][j]);
					}
				}
				writer.print("\n");
			}
			
			writer.print("\n\n");
			
			writer.close();
			
		} catch (FileNotFoundException ex) {
			//Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
			mensaje+="ERROR 1"+"\n";
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			mensaje+="ERROR 2"+"\n";
		} finally {
			mensaje+="FINAL"+"\n";
			writer.close();
		}
		
		return mensaje;
	}
	
	
	/**
	 * Carga una partida de damas guardada
	 */
	public String load_state(){
		// TODO
		
		
		String mensajes ="Cargando estado.\n";
		File archivo = null;
		FileReader fr = null;
		BufferedReader br = null;

		

		try {
			// Apertura del fichero y creacion de BufferedReader para poder
			// hacer una lectura comoda (disponer del metodo readLine()).
			archivo = new File("./estado.txt");
			fr = new FileReader(archivo);
			br = new BufferedReader(fr);

			// Lectura del fichero
			String linea;
			
			for(int i = 0; i < this.piezasTablero_.length; i++){
				
				linea = br.readLine();
				//mensajes+="\nLEIDO: " + linea;
				
				for(int j= 0; j < this.piezasTablero_[i].length; j++){
					
					if(linea.charAt(j) =='-'){
						this.piezasTablero_[i][j]="";
						//mensajes+="\nNO HAY FICHA"  +" EN LA POSICION: "+ i +" " +j;
					}
					else {
						this.piezasTablero_[i][j]= ""+ linea.charAt(j);
						//mensajes+="\nFICHA: " + linea.charAt(j) +" EN LA POSICION: "+ i +" " +j;
					}
					
				}	
			}
			
			fr.close();
			
/*			while ((linea = br.readLine()) != null) {
				
				if(linea.substring(0, 1).equals("-") || linea.substring(0, 1).equals("b") || linea.substring(0, 1).equals("n")){
					t
				}
				//editor.append(linea + "\n");
			}*/

		} catch (Exception e) {
			e.printStackTrace();

			
		} finally {
			// En el finally cerramos el fichero, para asegurarnos
			// que se cierra tanto si todo va bien como si salta
			// una excepcion.
			try {
				if (null != fr) {
					fr.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		
		return mensajes;
	}
	
	
	
	
	

	// ////////////////////////////////
	//
	// FUNCIONES PRIVADAS
	//
	// ////////////////////////////////

	/**
	 * Pinta una pieza en el tablero, dada sus coordenadas en la matriz de
	 * piezas y su tipo (b,B,n,N)
	 * 
	 * @param g2
	 *            Instancia de clase Graphics2D para pintar sobre el JTablero
	 * 
	 * @param casillaX
	 *            Numero de fila
	 * 
	 * @param casillaY
	 *            Numero de columna
	 * 
	 * @param pieza
	 *            Tipo de pieza: (n->negra, b->blanca) (minuculas->dama simple,
	 *            mayusculas->dama doble)
	 */
	private void ponerPieza(Graphics2D g2, int casillaX, int casillaY,
			String pieza) {

		// Calculamos la posicion de la pieza en la imagen
		int x = (casillaX * ladoCasilla_) + xT_;
		int y = (casillaY * ladoCasilla_) + yT_;

		// Vamos si la pieza es dama o no y si la casilla es blanca y negra
		// Casilla blanca y pieza negra
		if (pieza.equals("n") && ((casillaX + casillaY) % 2 == 0))
			g2.drawImage(damaNegraCB_, x, y, ladoCasilla_ + x,
					ladoCasilla_ + y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla negra y pieza negra
		else if (pieza.equals("n") && ((casillaX + casillaY) % 2 != 0))
			g2.drawImage(damaNegraCN_, x, y, ladoCasilla_ + x,
					ladoCasilla_ + y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla blanca y pieza blanca
		else if (pieza.equals("b") && ((casillaX + casillaY) % 2 == 0))
			g2.drawImage(damaBlancaCB_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla negra y pieza blanca
		else if (pieza.equals("b") && ((casillaX + casillaY) % 2 != 0))
			g2.drawImage(damaBlancaCN_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);

		// DAMAS DOBLES

		// Casilla blanca y pieza negra
		if (pieza.equals("N") && ((casillaX + casillaY) % 2 == 0))
			g2.drawImage(dama2NegraCB_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla negra y pieza negra
		else if (pieza.equals("N") && ((casillaX + casillaY) % 2 != 0))
			g2.drawImage(dama2NegraCN_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla blanca y pieza blanca
		else if (pieza.equals("B") && ((casillaX + casillaY) % 2 == 0))
			g2.drawImage(dama2BlancaCB_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);
		// Casilla negra y pieza blanca
		else if (pieza.equals("B") && ((casillaX + casillaY) % 2 != 0))
			g2.drawImage(dama2BlancaCN_, x, y, ladoCasilla_ + x, ladoCasilla_
					+ y, 0, 0, ladoCasilla_, ladoCasilla_, null);

	}

	/**
	 * Pone en blanco la matriz de piezas del tablero, sin redibujar el panel
	 * contenedor.
	 */
	void iniciarPiezasTablero() {

		String[][] piezasTablero = { { "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" },
				{ "", "", "", "", "", "", "", "" }, };

		this.piezasTablero_ = piezasTablero;
	}

	/**
	 * Genera un tablero en 3D en VRML con el estado actual (por ahora) del
	 * tablero 2D
	 * 
	 * @param nombreFichero
	 *            Tipo String con el nombre del archivo donde
	 * 
	 */

	/**
	 * Obtiene el numero a partir de la letra
	 * 
	 * @param letra
	 *            Letra que referencia una de las posiciones del tablero
	 * @return Devuelve la correspondencia de la letra con la posici�n del
	 *         tablero, en caso de error devuelve -1
	 */

	private int letraToNumero(String letra) {
		if (letra.equals("A") || letra.equals("a"))
			return 0;
		else if (letra.equals("B") || letra.equals("b"))
			return 1;
		else if (letra.equals("C") || letra.equals("c"))
			return 2;
		else if (letra.equals("D") || letra.equals("d"))
			return 3;
		else if (letra.equals("E") || letra.equals("e"))
			return 4;
		else if (letra.equals("F") || letra.equals("f"))
			return 5;
		else if (letra.equals("G") || letra.equals("g"))
			return 6;
		else if (letra.equals("H") || letra.equals("h"))
			return 7;
		else
			return -1;
	}
	
	private String NumeroToLetra(int num) {
		if (num==0)
			return "A";
		else if (num==1)
			return "B";
		else if (num==2)
			return "C";
		else if (num==3)
			return "D";
		else if (num==4)
			return "E";
		else if (num==5)
			return "F";
		else if (num==6)
			return "G";
		else if (num==7)
			return "H";
		else
			return "";
	}

	/**
	 * Funci�n que convierte un numero en su letra correspondiente del tablero.
	 * 
	 * @param numero
	 *            Numero a convertir en letra del tablero.
	 * @return Devuelve la letra que se corresponde con el numero.
	 */
	private String numeroToLetra(int numero) {
		if (numero == 0)
			return "A";
		else if (numero == 1)
			return "B";
		else if (numero == 2)
			return "C";
		else if (numero == 3)
			return "D";
		else if (numero == 4)
			return "E";
		else if (numero == 5)
			return "F";
		else if (numero == 6)
			return "G";
		else
			return "H";
	}

	/**
	 * Funcion que devuelve el color de la casilla
	 * 
	 * @param f
	 *            Numero de la fila
	 * @param c
	 *            Numero de la columna
	 * @return Devuelve el color de la casilla indicado por f y c.
	 */
	private String colorCasilla(int f, int c) {
		if (f == 0 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "W";
		else if (f == 0 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "B";
		else if (f == 1 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "B";
		else if (f == 1 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "W";
		else if (f == 2 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "W";
		else if (f == 2 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "B";
		else if (f == 3 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "B";
		else if (f == 3 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "W";
		else if (f == 4 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "W";
		else if (f == 4 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "B";
		else if (f == 5 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "B";
		else if (f == 5 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "W";
		else if (f == 6 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "W";
		else if (f == 6 && (c == 1 || c == 3 || c == 5 || c == 7))
			return "B";
		else if (f == 7 && (c == 0 || c == 2 || c == 4 || c == 6))
			return "B";
		else
			return "W";

	}
}